case NOP:         ++PC.pair; break;

case HALT__:			halt = 1; ++PC.pair; break;

case LD_BC_ii:    LD_pp_ii(BC.pair); break;
case LD_DE_ii:    LD_pp_ii(DE.pair); break;
case LD_HL_ii:    LD_pp_ii(HL.pair); break;
case LD_SP_ii:    LD_pp_ii(SP.pair); break;

case LD_mBC_A:    MemWriteB(BC.pair, AF.reg.A); ++PC.pair; break;
case LD_mDE_A:    MemWriteB(DE.pair, AF.reg.A); ++PC.pair; break;

case INC_BC:      ++BC.pair; ++PC.pair; break;
case INC_DE:      ++DE.pair; ++PC.pair; break;
case INC_HL:      ++HL.pair; ++PC.pair; break;
case INC_SP:      ++SP.pair; ++PC.pair; break;

case LD_B_B:      ++PC.pair; break;
case LD_C_C:      ++PC.pair; break;
case LD_D_D:      ++PC.pair; break;
case LD_E_E:      ++PC.pair; break;
case LD_H_H:      ++PC.pair; break;
case LD_A_A:      ++PC.pair; break;

case LD_B_C:      BC.reg.B = BC.reg.C; ++PC.pair; break;
case LD_B_D:      BC.reg.B = DE.reg.D; ++PC.pair; break;
case LD_B_E:      BC.reg.B = DE.reg.E; ++PC.pair; break;
case LD_B_H:      BC.reg.B = HL.reg.H; ++PC.pair; break;
case LD_B_L:      BC.reg.B = HL.reg.L; ++PC.pair; break;
case LD_B_A:      BC.reg.B = AF.reg.A; ++PC.pair; break;

case LD_C_B:      BC.reg.C = BC.reg.B; ++PC.pair; break;
case LD_C_D:      BC.reg.C = DE.reg.D; ++PC.pair; break;
case LD_C_E:      BC.reg.C = DE.reg.E; ++PC.pair; break;
case LD_C_H:      BC.reg.C = HL.reg.H; ++PC.pair; break;
case LD_C_L:      BC.reg.C = HL.reg.L; ++PC.pair; break;
case LD_C_A:      BC.reg.C = AF.reg.A; ++PC.pair; break;

case LD_D_B:      DE.reg.D = BC.reg.B; ++PC.pair; break;
case LD_D_C:      DE.reg.D = BC.reg.C; ++PC.pair; break;
case LD_D_E:      DE.reg.D = DE.reg.E; ++PC.pair; break;
case LD_D_H:      DE.reg.D = HL.reg.H; ++PC.pair; break;
case LD_D_L:      DE.reg.D = HL.reg.L; ++PC.pair; break;
case LD_D_A:      DE.reg.D = AF.reg.A; ++PC.pair; break;

case LD_E_B:      DE.reg.E = BC.reg.B; ++PC.pair; break;
case LD_E_C:      DE.reg.E = BC.reg.C; ++PC.pair; break;
case LD_E_D:      DE.reg.E = DE.reg.D; ++PC.pair; break;
case LD_E_H:      DE.reg.E = HL.reg.H; ++PC.pair; break;
case LD_E_L:      DE.reg.E = HL.reg.L; ++PC.pair; break;
case LD_E_A:      DE.reg.E = AF.reg.A; ++PC.pair; break;

case LD_H_B:      HL.reg.H = BC.reg.B; ++PC.pair; break;
case LD_H_C:      HL.reg.H = BC.reg.C; ++PC.pair; break;
case LD_H_D:      HL.reg.H = DE.reg.D; ++PC.pair; break;
case LD_H_E:      HL.reg.H = DE.reg.E; ++PC.pair; break;
case LD_H_L:      HL.reg.H = HL.reg.L; ++PC.pair; break;
case LD_H_A:      HL.reg.H = AF.reg.A; ++PC.pair; break;

case LD_L_B:      HL.reg.L = BC.reg.B; ++PC.pair; break;
case LD_L_C:      HL.reg.L = BC.reg.C; ++PC.pair; break;
case LD_L_D:      HL.reg.L = DE.reg.D; ++PC.pair; break;
case LD_L_E:      HL.reg.L = DE.reg.E; ++PC.pair; break;
case LD_L_H:      HL.reg.L = HL.reg.H; ++PC.pair; break;
case LD_L_A:      HL.reg.L = AF.reg.A; ++PC.pair; break;

case LD_A_B:      AF.reg.A = BC.reg.B; ++PC.pair; break;
case LD_A_C:      AF.reg.A = BC.reg.C; ++PC.pair; break;
case LD_A_D:      AF.reg.A = DE.reg.D; ++PC.pair; break;
case LD_A_E:      AF.reg.A = DE.reg.E; ++PC.pair; break;
case LD_A_H:      AF.reg.A = HL.reg.H; ++PC.pair; break;
case LD_A_L:      AF.reg.A = HL.reg.L; ++PC.pair; break;

case LD_SP_HL:    SP.pair = HL.pair; ++PC.pair; break;

case DEC_DE:      --DE.pair; ++PC.pair; break;
case DEC_BC:      --BC.pair; ++PC.pair; break;
case DEC_HL:      --HL.pair; ++PC.pair; break;
case DEC_SP:      --SP.pair; ++PC.pair; break;

case LD_mHL_B:    MemWriteB(HL.pair, BC.reg.B); ++PC.pair; break;
case LD_mHL_C:    MemWriteB(HL.pair, BC.reg.C); ++PC.pair; break;
case LD_mHL_D:    MemWriteB(HL.pair, DE.reg.D); ++PC.pair; break;
case LD_mHL_E:    MemWriteB(HL.pair, DE.reg.E); ++PC.pair; break;
case LD_mHL_H:    MemWriteB(HL.pair, HL.reg.H); ++PC.pair; break;
case LD_mHL_L:    MemWriteB(HL.pair, HL.reg.L); ++PC.pair; break;
case LD_mHL_A:    MemWriteB(HL.pair, AF.reg.A); ++PC.pair; break;

case LD_mHL_i:    MemWriteB(HL.pair,MemReadB(++PC.pair)); ++PC.pair; break;

case LD_A_mBC:    AF.reg.A = MemReadB(BC.pair); ++PC.pair; break;
case LD_A_mDE:    AF.reg.A = MemReadB(DE.pair); ++PC.pair; break;

case LD_B_mHL:    BC.reg.B = MemReadB(HL.pair); ++PC.pair; break;
case LD_C_mHL:    BC.reg.C = MemReadB(HL.pair); ++PC.pair; break;
case LD_D_mHL:    DE.reg.D = MemReadB(HL.pair); ++PC.pair; break;
case LD_E_mHL:    DE.reg.E = MemReadB(HL.pair); ++PC.pair; break;
case LD_H_mHL:    HL.reg.H = MemReadB(HL.pair); ++PC.pair; break;
case LD_L_mHL:    HL.reg.L = MemReadB(HL.pair); ++PC.pair; break;
case LD_A_mHL:    AF.reg.A = MemReadB(HL.pair); ++PC.pair; break;

case LD_B_i:      BC.reg.B = MemReadB(++PC.pair); ++PC.pair; break;
case LD_C_i:      BC.reg.C = MemReadB(++PC.pair); ++PC.pair; break;
case LD_D_i:      DE.reg.D = MemReadB(++PC.pair); ++PC.pair; break;
case LD_E_i:      DE.reg.E = MemReadB(++PC.pair); ++PC.pair; break;
case LD_H_i:      HL.reg.H = MemReadB(++PC.pair); ++PC.pair; break;
case LD_L_i:      HL.reg.L = MemReadB(++PC.pair); ++PC.pair; break;
case LD_A_i:      AF.reg.A = MemReadB(++PC.pair); ++PC.pair; break;

case INC_B:       INC_r(BC.reg.B); break;
case INC_C:       INC_r(BC.reg.C); break;
case INC_D:       INC_r(DE.reg.D); break;
case INC_E:       INC_r(DE.reg.E); break;
case INC_H:       INC_r(HL.reg.H); break;
case INC_L:       INC_r(HL.reg.L); break;
case INC_A:       INC_r(AF.reg.A); break;

case DEC_B:			DEC_r(BC.reg.B); break;
case DEC_C:			DEC_r(BC.reg.C); break;
case DEC_D:			DEC_r(DE.reg.D); break;
case DEC_E:			DEC_r(DE.reg.E); break;
case DEC_H:			DEC_r(HL.reg.H); break;
case DEC_L:			DEC_r(HL.reg.L); break;
case DEC_A:			DEC_r(AF.reg.A); break;

case INC_mHL:		INC_m(HL.pair); break;
case DEC_mHL:		DEC_m(HL.pair); break;

case EX_AF_AFx:		EX_pp(AF.pair,AFx.pair); break;

case EX_DE_HL:		EX_pp(DE.pair,HL.pair); break;

case LD_A_mii:		++PC.pair; AF.reg.A = MemReadB(MemReadW(PC.pair)); PC.pair += 2; break;

case LD_HL_mii:		++PC.pair; HL.pair = MemReadW(MemReadW(PC.pair)); PC.pair += 2; break;

case LD_mii_A:		++PC.pair; MemWriteB(MemReadW(PC.pair),AF.reg.A); PC.pair += 2; break;

case LD_mii_HL:		++PC.pair; MemWriteW(MemReadW(PC.pair),HL.pair); PC.pair += 2; break;

case EXX:			EX(BC.pair,BCx.pair); EX(DE.pair,DEx.pair); EX(HL.pair,HLx.pair); ++PC.pair; break;

case SCF:			AF.reg.F = CPY_FLAGS(S_FLAG|Z_FLAG|P_FLAG) | (C_FLAG); ++PC.pair; break;

case RLCA: {
	tmp_b = ((AF.reg.A & BIT7)?C_FLAG:0);
	AF.reg.F = CPY_FLAGS(S_FLAG|Z_FLAG|P_FLAG) | (tmp_b);
	AF.reg.A = (AF.reg.A << 1) | (tmp_b);
	++PC.pair;
	break;
}

case RLA: {
	tmp_b = (AF.reg.F & C_FLAG);
	AF.reg.F = CPY_FLAGS(S_FLAG|Z_FLAG|P_FLAG) | ((AF.reg.A & BIT7)?C_FLAG:0);
	AF.reg.A = (AF.reg.A << 1) | (tmp_b);
	++PC.pair;
	break;
}

case RRCA: {
	tmp_b = (AF.reg.A & BIT0);
	AF.reg.F = CPY_FLAGS(S_FLAG|Z_FLAG|P_FLAG) | (tmp_b);
	AF.reg.A = (AF.reg.A >> 1) | (tmp_b?BIT7:0);
	++PC.pair;
	break;
}

case RRA: {
	tmp_b = ((AF.reg.F & C_FLAG)?BIT7:0);
	AF.reg.F = CPY_FLAGS(S_FLAG|Z_FLAG|P_FLAG) | (AF.reg.A & BIT0);
	AF.reg.A = (AF.reg.A >> 1) | (tmp_b);
	++PC.pair;
	break;
}

case CCF: {
	AF.reg.F = CPY_FLAGS(S_FLAG|Z_FLAG|P_FLAG) | ((AF.reg.F&C_FLAG)?H_FLAG:C_FLAG);
	++PC.pair;
	break;
}

case CPL: {
	AF.reg.F |= (H_FLAG | N_FLAG);
	AF.reg.A = (~AF.reg.A);
	++PC.pair;
	break;
}

case AND_A_B:			AND_(BC.reg.B); ++PC.pair; break;
case AND_A_C:			AND_(BC.reg.C); ++PC.pair; break;
case AND_A_D:			AND_(DE.reg.D); ++PC.pair; break;
case AND_A_E:			AND_(DE.reg.E); ++PC.pair; break;
case AND_A_H:			AND_(HL.reg.H); ++PC.pair; break;
case AND_A_L:			AND_(HL.reg.L); ++PC.pair; break;
case AND_A_A:			AND_(AF.reg.A); ++PC.pair; break;

case AND_A_i:			++PC.pair; AND_(MemReadB(PC.pair)); ++PC.pair; break;

case XOR_A_B:			XOR_(BC.reg.B);
case XOR_A_C:			XOR_(BC.reg.C);
case XOR_A_D:			XOR_(DE.reg.D);
case XOR_A_E:			XOR_(DE.reg.E);
case XOR_A_H:			XOR_(HL.reg.H);
case XOR_A_L:			XOR_(HL.reg.L);
case XOR_A_A:			XOR_(AF.reg.A);

case XOR_A_i:			++PC.pair; XOR_(MemReadB(PC.pair)); ++PC.pair; break;

case OR_A_B:			OR_(BC.reg.B);
case OR_A_C:			OR_(BC.reg.C);
case OR_A_D:			OR_(DE.reg.D);
case OR_A_E:			OR_(DE.reg.E);
case OR_A_H:			OR_(HL.reg.H);
case OR_A_L:			OR_(HL.reg.L);
case OR_A_A:			OR_(AF.reg.A);

case OR_A_i:			++PC.pair; OR_(MemReadB(PC.pair)); ++PC.pair; break;

case XOR_A_mHL:		XOR_(MemReadB(HL.pair)); ++PC.pair; break;
case AND_A_mHL:		AND_(MemReadB(HL.pair)); ++PC.pair; break;
case OR_A_mHL:		OR_(MemReadB(HL.pair)); ++PC.pair; break;

case PUSH_BC:		PUSH(BC.reg.B,BC.reg.C); ++PC.pair; break;
case PUSH_DE:		PUSH(DE.reg.D,DE.reg.E); ++PC.pair; break;
case PUSH_HL:		PUSH(HL.reg.H,HL.reg.L); ++PC.pair; break;
case PUSH_AF:		PUSH(AF.reg.A,AF.reg.F); ++PC.pair; break;

case POP_BC:		POP(BC.reg.B,BC.reg.C); ++PC.pair; break;
case POP_DE:		POP(DE.reg.D,DE.reg.E); ++PC.pair; break;
case POP_HL:		POP(HL.reg.H,HL.reg.L); ++PC.pair; break;
case POP_AF:		POP(AF.reg.A,AF.reg.F); ++PC.pair; break;

case CALL_ii:		CALL; break;

case CALL_Z_ii:		CCALL(CPY_FLAGS(Z_FLAG)); break;
case CALL_NZ_ii:	CCALL(!CPY_FLAGS(Z_FLAG)); break;

case CALL_C_ii:		CCALL(CPY_FLAGS(C_FLAG)); break;
case CALL_NC_ii:	CCALL(!CPY_FLAGS(C_FLAG)); break;

case CALL_PE_ii:	CCALL(CPY_FLAGS(P_FLAG)); break;
case CALL_PO_ii:	CCALL(!CPY_FLAGS(P_FLAG)); break;

case CALL_P_ii:		CCALL(!CPY_FLAGS(S_FLAG)); break;
case CALL_M_ii:		CCALL(CPY_FLAGS(S_FLAG)); break;

case RET:			POP(PC.reg.P,PC.reg.C); break;

case RET_Z:			if (CPY_FLAGS(Z_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;
case RET_NZ:		if (!CPY_FLAGS(Z_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;

case RET_C:			if (CPY_FLAGS(C_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;
case RET_NC:		if (!CPY_FLAGS(C_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;

case RET_PE:		if (CPY_FLAGS(P_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;
case RET_PO:		if (!CPY_FLAGS(P_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;

case RET_M:			if (CPY_FLAGS(S_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;
case RET_P:			if (!CPY_FLAGS(S_FLAG)) { POP(PC.reg.P,PC.reg.C); } else { ++PC.pair; } break;

case JZ_ii:			if (CPY_FLAGS(Z_FLAG)) { JMP; } else { PC.pair+=3; } break;
case JNZ_ii:		if (!CPY_FLAGS(Z_FLAG)) { JMP; } else { PC.pair+=3; } break;

case JC_ii:			if (CPY_FLAGS(C_FLAG)) { JMP; } else { PC.pair+=3; } break;
case JNC_ii:		if (!CPY_FLAGS(C_FLAG)) { JMP; } else { PC.pair+=3; } break;

case JPE_ii:		if (CPY_FLAGS(P_FLAG)) { JMP; } else { PC.pair+=3; } break;
case JPO_ii:		if (!CPY_FLAGS(P_FLAG)) { JMP; } else { PC.pair+=3; } break;

case JM_ii:			if (CPY_FLAGS(S_FLAG)) { JMP; } else { PC.pair+=3; } break;
case JP_ii:			if (!CPY_FLAGS(S_FLAG)) { JMP; } else { PC.pair+=3; } break;

case JUMP_ii:		JMP; break;

case JP_mHL:		PC.pair = HL.pair; break;

//case IN_A_mi:		AF.reg.A = DeviceRead(MemReadB(++PC.pair)); ++PC.pair; break;
//case OUT_mi_A:		DeviceWrite(++PC.pair,AF.reg.A); ++PC.pair; break;

case DJNZ_e:		PC.pair += ((--BC.reg.B)?(MemReadB(++PC.pair)+1):(1)); break;

case JR_e:			JR; break;

case JR_Z_e:		if (CPY_FLAGS(Z_FLAG)) { JR; } else { PC.pair+=2; } break;
case JR_NZ_e:		if (!CPY_FLAGS(Z_FLAG)) { JR; } else { PC.pair+=2; } break;

case JR_C_e:		if (CPY_FLAGS(C_FLAG)) { JR; } else { PC.pair+=2; } break;
case JR_NC_e:		if (!CPY_FLAGS(C_FLAG)) { JR; } else { PC.pair+=2; } break;

case RST_00H:		RST(0); break;
case RST_08H:		RST(0x8); break;
case RST_10H:		RST(0x10); break;
case RST_18H:		RST(0x18); break;
case RST_20H:		RST(0x20); break;
case RST_28H:		RST(0x28); break;
case RST_30H:		RST(0x30); break;
case RST_38H:		RST(0x38); break;

case EX_mSP_HL: {
	tmp_w.pair = MemReadW(SP.pair);
	MemWriteW(SP.pair,HL.pair);
	HL.pair = tmp_w.pair;
	++PC.pair;
	break;
}

case ADD_HL_BC:   ADD_pp(HL.pair,BC.pair);
case ADD_HL_DE:   ADD_pp(HL.pair,DE.pair);
case ADD_HL_HL:   ADD_pp(HL.pair,HL.pair);
case ADD_HL_SP:   ADD_pp(HL.pair,SP.pair);

case ADD_A_B:     ADD_r(BC.reg.B);
case ADD_A_C:     ADD_r(BC.reg.C);
case ADD_A_D:     ADD_r(DE.reg.D);
case ADD_A_E:     ADD_r(DE.reg.E);
case ADD_A_H:     ADD_r(HL.reg.H);
case ADD_A_L:     ADD_r(HL.reg.L);
case ADD_A_A:     ADD_r(AF.reg.A);

case ADD_A_i:     ++PC.pair; ADD_r(MemReadB(PC.pair));

case ADD_A_mHL:   ADD_r(MemReadB(HL.pair));

case SUB_A_B:       SUB_r(BC.reg.B);
case SUB_A_C:       SUB_r(BC.reg.C);
case SUB_A_D:       SUB_r(DE.reg.D);
case SUB_A_E:       SUB_r(DE.reg.E);
case SUB_A_H:       SUB_r(HL.reg.H);
case SUB_A_L:       SUB_r(HL.reg.L);
case SUB_A_A:       SUB_r(AF.reg.A);

case SUB_A_i:       ++PC.pair; SUB_r(MemReadB(PC.pair));

case SUB_A_mHL:     SUB_r(MemReadB(HL.pair));

case CP_A_B:        CP_(BC.reg.B);
case CP_A_C:        CP_(BC.reg.C);
case CP_A_D:        CP_(DE.reg.D);
case CP_A_E:        CP_(DE.reg.E);
case CP_A_H:        CP_(HL.reg.H);
case CP_A_L:        CP_(HL.reg.L);
case CP_A_A:        CP_(AF.reg.A);

case CP_A_mHL:      CP_(MemReadB(HL.pair));

case CP_A_i:        ++PC.pair; CP_(MemReadB(PC.pair));

case ADC_A_A:		ADC_(AF.reg.A);
case ADC_A_B:		ADC_(BC.reg.B);
case ADC_A_C:		ADC_(BC.reg.C);
case ADC_A_D:		ADC_(DE.reg.D);
case ADC_A_E:		ADC_(DE.reg.E);
case ADC_A_H:		ADC_(HL.reg.H);
case ADC_A_L:		ADC_(HL.reg.L);

case ADC_A_i:		++PC.pair; ADC_(MemReadB(PC.pair));

case ADC_A_mHL:		ADC_(MemReadB(HL.pair));

case SBC_A_A:		SBC_(AF.reg.A);
case SBC_A_B:		SBC_(BC.reg.B);
case SBC_A_C:		SBC_(BC.reg.C);
case SBC_A_D:		SBC_(DE.reg.D);
case SBC_A_E:		SBC_(DE.reg.E);
case SBC_A_H:		SBC_(HL.reg.H);
case SBC_A_L:		SBC_(HL.reg.L);

case SBC_A_i:		++PC.pair; SBC_(MemReadB(PC.pair));

case SBC_A_mHL:		SBC_(MemReadB(HL.pair));

case DAA:			AF.pair = iDAATable[AF.reg.A]; ++PC.pair; break;

case DI:			IFF = 0; ++PC.pair; break;
case EI:			IFF = 1; ++PC.pair; break;

/* Prefixes */

case preCB:
//	#include "PrefixCB.h"
	break;

case preED:
//	#include "PrefixED.h"
	break;

case preFD:
//	#include "PrefixFD.h"
	break;

case preDD:
//	#include "PrefixDD.h"
	break;
